/**
 * 前端权限控制系统
 * 根据用户权限动态显示/隐藏功能按钮和菜单项
 */

class FrontendPermissionManager {
    constructor() {
        this.currentUser = null;
        this.userPermissions = [];
        this.userRoles = [];
        this.init();
    }

    async init() {
        // 检查是否刚刚登录（5秒内），如果是则延迟权限检查
        const loginTime = localStorage.getItem('login_time');
        const now = Date.now();
        if (loginTime && (now - parseInt(loginTime)) < 5000) {
            setTimeout(() => this.loadCurrentUser(), 1000);
        } else {
            await this.loadCurrentUser();
        }
        this.applyPermissionControls();
    }

    /**
     * 加载当前用户信息和权限
     */
    async loadCurrentUser() {
        try {
            const token = localStorage.getItem('access_token');
            if (!token) {
                this.redirectToLogin();
                return;
            }

            const response = await fetch('/api/users/current', {
                headers: {
                    'Authorization': `Bearer ${token}`
                }
            });

            if (response.ok) {
                const data = await response.json();
                this.currentUser = data.data;
                this.userRoles = this.currentUser.roles || [];
                
                // 获取用户权限
                await this.loadUserPermissions();
            } else if (response.status === 401) {
                // Token过期或无效，清理本地存储
                localStorage.removeItem('access_token');
                localStorage.removeItem('login_time');
                this.redirectToLogin();
            } else {
                // 其他错误，可能是网络问题，不立即重定向
                console.warn('加载用户信息失败，状态码:', response.status);
            }
        } catch (error) {
            console.error('加载用户信息失败:', error);
            // 网络错误，不立即重定向，给用户机会重试
        }
    }

    /**
     * 加载用户权限列表
     */
    async loadUserPermissions() {
        try {
            const token = localStorage.getItem('access_token');
            const response = await fetch('/api/users/current/permissions', {
                headers: {
                    'Authorization': `Bearer ${token}`
                }
            });

            if (response.ok) {
                const data = await response.json();
                this.userPermissions = data.data || [];
            }
        } catch (error) {
            console.error('加载用户权限失败:', error);
        }
    }

    /**
     * 检查用户是否拥有指定角色
     */
    hasRole(roleName) {
        return this.userRoles.includes(roleName);
    }

    /**
     * 检查用户是否拥有指定权限
     */
    hasPermission(permission) {
        return this.userPermissions.includes(permission);
    }

    /**
     * 检查用户是否拥有任一指定权限
     */
    hasAnyPermission(permissions) {
        if (!Array.isArray(permissions)) {
            permissions = [permissions];
        }
        return permissions.some(perm => this.hasPermission(perm));
    }

    /**
     * 检查用户是否拥有所有指定权限
     */
    hasAllPermissions(permissions) {
        if (!Array.isArray(permissions)) {
            permissions = [permissions];
        }
        return permissions.every(perm => this.hasPermission(perm));
    }

    /**
     * 应用权限控制到页面元素
     */
    applyPermissionControls() {
        // 处理需要特定权限的元素
        document.querySelectorAll('[data-require-permission]').forEach(element => {
            const requiredPermission = element.getAttribute('data-require-permission');
            if (!this.hasPermission(requiredPermission)) {
                this.hideOrDisableElement(element);
            }
        });

        // 处理需要特定角色的元素
        document.querySelectorAll('[data-require-role]').forEach(element => {
            const requiredRole = element.getAttribute('data-require-role');
            if (!this.hasRole(requiredRole)) {
                this.hideOrDisableElement(element);
            }
        });

        // 处理需要任一权限的元素
        document.querySelectorAll('[data-require-any-permission]').forEach(element => {
            const requiredPermissions = element.getAttribute('data-require-any-permission').split(',');
            if (!this.hasAnyPermission(requiredPermissions)) {
                this.hideOrDisableElement(element);
            }
        });

        // 处理需要所有权限的元素
        document.querySelectorAll('[data-require-all-permissions]').forEach(element => {
            const requiredPermissions = element.getAttribute('data-require-all-permissions').split(',');
            if (!this.hasAllPermissions(requiredPermissions)) {
                this.hideOrDisableElement(element);
            }
        });

        // 处理管理员专用元素
        document.querySelectorAll('[data-admin-only]').forEach(element => {
            if (!this.hasRole('admin')) {
                this.hideOrDisableElement(element);
            }
        });

        // 应用特定功能的权限控制
        this.applySpecificPermissionControls();
    }

    /**
     * 隐藏或禁用元素
     */
    hideOrDisableElement(element) {
        const action = element.getAttribute('data-permission-action') || 'hide';
        
        if (action === 'disable') {
            element.disabled = true;
            element.classList.add('disabled');
            element.title = '权限不足';
        } else {
            element.style.display = 'none';
        }
    }

    /**
     * 应用特定功能的权限控制
     */
    applySpecificPermissionControls() {
        // 用户管理相关
        this.controlUserManagementFeatures();
        
        // 学生管理相关
        this.controlStudentManagementFeatures();
        
        // 视力数据相关
        this.controlVisionDataFeatures();
        
        // 导出功能
        this.controlExportFeatures();
        
        // 系统管理相关
        this.controlSystemManagementFeatures();
    }

    /**
     * 控制用户管理功能
     */
    controlUserManagementFeatures() {
        // 创建用户按钮
        this.controlElement('#createUserBtn', 'user:create');
        
        // 编辑用户按钮
        document.querySelectorAll('.edit-user-btn').forEach(btn => {
            if (!this.hasPermission('user:edit')) {
                this.hideOrDisableElement(btn);
            }
        });
        
        // 删除用户按钮
        document.querySelectorAll('.delete-user-btn').forEach(btn => {
            if (!this.hasPermission('user:delete')) {
                this.hideOrDisableElement(btn);
            }
        });
        
        // 角色分配功能
        document.querySelectorAll('.assign-role-btn').forEach(btn => {
            if (!this.hasPermission('user:role_assign')) {
                this.hideOrDisableElement(btn);
            }
        });
    }

    /**
     * 控制学生管理功能
     */
    controlStudentManagementFeatures() {
        // 创建学生按钮
        this.controlElement('#createStudentBtn', 'student:create');
        
        // 编辑学生按钮
        document.querySelectorAll('.edit-student-btn').forEach(btn => {
            if (!this.hasPermission('student:edit')) {
                this.hideOrDisableElement(btn);
            }
        });
        
        // 删除学生按钮
        document.querySelectorAll('.delete-student-btn').forEach(btn => {
            if (!this.hasPermission('student:delete')) {
                this.hideOrDisableElement(btn);
            }
        });
    }

    /**
     * 控制视力数据功能
     */
    controlVisionDataFeatures() {
        // 编辑视力记录按钮
        document.querySelectorAll('.edit-vision-btn').forEach(btn => {
            if (!this.hasPermission('vision:edit')) {
                this.hideOrDisableElement(btn);
            }
        });
        
        // 删除视力记录按钮
        document.querySelectorAll('.delete-vision-btn').forEach(btn => {
            if (!this.hasPermission('vision:delete')) {
                this.hideOrDisableElement(btn);
            }
        });
    }

    /**
     * 控制导出功能
     */
    controlExportFeatures() {
        document.querySelectorAll('.export-btn, [data-action="export"]').forEach(btn => {
            if (!this.hasPermission('data:export')) {
                this.hideOrDisableElement(btn);
            }
        });
    }

    /**
     * 控制系统管理功能
     */
    controlSystemManagementFeatures() {
        // 角色管理
        this.controlElement('#roleManagementBtn', 'role:read');
        
        // 权限管理
        this.controlElement('#permissionManagementBtn', 'permission:read');
        
        // 系统日志
        this.controlElement('#systemLogBtn', 'log:view');
        
        // 隐藏系统管理菜单项（如果用户没有任何系统管理权限）
        const systemMenuItems = document.querySelectorAll('.system-menu-item');
        const hasAnySystemPermission = this.hasAnyPermission([
            'role:read', 'permission:read', 'log:view', 'system:config'
        ]);
        
        if (!hasAnySystemPermission) {
            systemMenuItems.forEach(item => {
                item.style.display = 'none';
            });
        }
    }

    /**
     * 控制单个元素
     */
    controlElement(selector, permission) {
        const element = document.querySelector(selector);
        if (element && !this.hasPermission(permission)) {
            this.hideOrDisableElement(element);
        }
    }

    /**
     * 为按钮添加权限检查
     */
    addPermissionCheck(selector, permission, callback) {
        const elements = document.querySelectorAll(selector);
        elements.forEach(element => {
            element.addEventListener('click', (e) => {
                if (!this.hasPermission(permission)) {
                    e.preventDefault();
                    e.stopPropagation();
                    this.showPermissionDeniedMessage();
                    return false;
                }
                if (callback) {
                    callback(e);
                }
            });
        });
    }

    /**
     * 显示权限不足提示
     */
    showPermissionDeniedMessage() {
        if (window.Swal) {
            Swal.fire({
                icon: 'warning',
                title: '权限不足',
                text: '您没有权限执行此操作',
                confirmButtonText: '确定'
            });
        } else {
            alert('权限不足：您没有权限执行此操作');
        }
    }

    /**
     * 重定向到登录页面
     */
    redirectToLogin() {
        // 如果当前在index页面且刚刚登录成功(通过URL参数或localStorage检查)，不立即重定向
        // 给token一些时间生效
        if (window.location.pathname === '/index') {
            const loginTime = localStorage.getItem('login_time');
            const now = Date.now();
            // 如果登录时间在5秒内，延迟重定向检查
            if (loginTime && (now - parseInt(loginTime)) < 5000) {
                console.log('刚登录成功，延迟权限检查...');
                setTimeout(() => {
                    this.loadCurrentUser();
                }, 2000);
                return;
            }
        }
        
        if (window.location.pathname !== '/login' && window.location.pathname !== '/') {
            window.location.href = '/';
        }
    }

    /**
     * 获取当前用户信息
     */
    getCurrentUser() {
        return this.currentUser;
    }

    /**
     * 获取用户权限列表
     */
    getUserPermissions() {
        return this.userPermissions;
    }

    /**
     * 获取用户角色列表
     */
    getUserRoles() {
        return this.userRoles;
    }
}

// 全局权限管理器实例
let permissionManager;

// 页面加载完成后初始化权限管理器
document.addEventListener('DOMContentLoaded', function() {
    permissionManager = new FrontendPermissionManager();
});

// 导出权限检查函数供其他脚本使用
window.checkPermission = function(permission) {
    return permissionManager ? permissionManager.hasPermission(permission) : false;
};

window.checkRole = function(role) {
    return permissionManager ? permissionManager.hasRole(role) : false;
};

window.getCurrentUser = function() {
    return permissionManager ? permissionManager.getCurrentUser() : null;
};
